home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / program / szadb1_4.zoo / src / adb1.c < prev    next >
C/C++ Source or Header  |  1991-01-24  |  13KB  |  634 lines
  1. /* Copyright (c) 1990 by Sozobon, Limited.  Authors: Johann Ruegg, Don Dugger
  2.  *
  3.  * Permission is granted to anyone to use this software for any purpose
  4.  * on any computer system, and to redistribute it freely, with the
  5.  * following restrictions:
  6.  * 1) No charge may be made other than reasonable charges for reproduction.
  7.  * 2) Modified versions must be clearly marked as such.
  8.  * 3) The authors are not responsible for any harmful consequences
  9.  *    of using this software, even if they result from defects in it.
  10.  *
  11.  *    adb1.c
  12.  */
  13. /*
  14.  * Modifications:
  15.  *   - added functions to handle MWC format symbol table and hooks to
  16.  *     possibly add other formats
  17.  *   - added functions for buffered output to external files
  18.  *
  19.  *   Michal Jaegermann, May 1990
  20.  *
  21.  *   - function setsym() modified to handle also extended format in
  22.  *     which function name can be continued in the next symbol slot
  23.  *   - added function extndsymb() which checks if symbols are using
  24.  *     extended format
  25.  *
  26.  *   Michal Jaegermann, January 1991
  27.  */
  28.  
  29. #include <setjmp.h>
  30. #include "adb.h"
  31.  
  32. #define IN_ADB1
  33. #include "lang.h"
  34.  
  35. extern struct file binary;
  36.  
  37. extern long     dot;
  38. extern int      dotoff;
  39. extern long     maxoff;
  40. extern int      ibase;
  41.  
  42. extern int      lastc;
  43. extern char     sign;
  44.  
  45. extern int      swidth;
  46. extern jmp_buf  jmpb;
  47. extern int      trid;
  48. extern w_buf   *trbuf;
  49. extern char    *trname;
  50.  
  51. getfmt (fmt)
  52.     register char  *fmt;
  53. {
  54.     int             in_string = 0;
  55.  
  56.     while ((*fmt = getchr (in_string)) != '\n') {
  57.     if ('"' == *fmt)
  58.         in_string = !in_string;
  59.     fmt++;
  60.     }
  61.     *fmt = '\0';
  62.     PUSHC ('\n');
  63.     return;
  64. }
  65.  
  66. long
  67. getdot (d, n)
  68.     long            d;
  69.     int             n;
  70. {
  71.     long            l;
  72.  
  73.     l = dot;
  74.     if (n == 2)
  75.     l &= 0xffff;
  76.     else if (n == 1)
  77.     l &= 0xff;
  78.     return (l);
  79. }
  80.  
  81. #ifdef GONER
  82. unsigned char
  83. getb (fp)
  84.     struct file    *fp;
  85. {
  86.     long            getn ();
  87.  
  88.     return (getn (dot + dotoff, 1));
  89. }
  90. #endif
  91.  
  92. unsigned int
  93. getwd ()
  94. {
  95.     long            getn ();
  96.  
  97.     return (getn (dot + dotoff, 2));
  98. }
  99.  
  100. putn (v, d, n)
  101.     long            v, d;
  102.     int             n;
  103. {
  104.     union {
  105.     int             i;
  106.     long            l;
  107.     }               no, val;
  108.     long            b;
  109.     register int    o;
  110.     char           *p, *s;
  111.  
  112.     b = d >> LOGBS;
  113.     o = d & (BSIZE - 1);
  114.     switch (n) {
  115.  
  116.     case 2:
  117.     p = (char *) (&no.i);
  118.     val.i = v;
  119.     s = (char *) (&val.i);
  120.     break;
  121.     case 4:
  122.     p = (char *) (&no.l);
  123.     val.l = v;
  124.     s = (char *) (&val.l);
  125.     break;
  126.  
  127.     }
  128.     rdsub (d, p, n, 0);
  129.     dotoff += n;
  130.     switch (n) {
  131.  
  132.     case 2:
  133.     bcopy (s, p, n);
  134.     break;
  135.     case 4:
  136.     bcopy (s, p, n);
  137.     break;
  138.  
  139.     }
  140.     wrsub (p, d, n, 0);
  141.     return;
  142. }
  143.  
  144. long
  145. getn (d, n)
  146.     unsigned long   d;
  147.     int             n;
  148. {
  149.     unsigned long   b, no;
  150.     register unsigned int o;
  151.     char           *p;
  152.  
  153.     b = d >> LOGBS;
  154.     o = d & (BSIZE - 1);
  155.     rdsub (d, &b, n, 0);
  156.     p = (char *) &b;
  157.     dotoff += n;
  158.     switch (n) {
  159.  
  160.     case 1:
  161.     no = *p;
  162.     break;
  163.     case 2:
  164.     no = *(int *) p;
  165.     break;
  166.     case 4:
  167.     no = *(long *) p;
  168.     break;
  169.  
  170.     }
  171.     return (no);
  172. }
  173.  
  174. puto (n, s)
  175.     unsigned long   n;
  176.     int             s;
  177. {
  178.  
  179.     if (n > 0)
  180.     puto ((n >> 3) & 0x1fffffff, --s);
  181.     else
  182.     while (s-- > 0)
  183.         putchr (' ');
  184.     putchr ((char) ((n & 7) + '0'));
  185.     return;
  186. }
  187.  
  188. putd (n, s)
  189.     long            n;
  190.     int             s;
  191. {
  192.  
  193.     if (n < 0) {
  194.     s--;
  195.     n = -n;
  196.     if (n < 0) {
  197.         while (s-- > 0)
  198.         putchr (' ');
  199.         putchr ('?');
  200.         return;
  201.     }
  202.     else
  203.         sign = '-';
  204.     }
  205.     if (n > 9)
  206.     putd (n / 10, --s);
  207.     else
  208.     while (s-- > 0)
  209.         putchr (' ');
  210.     if (sign) {
  211.     putchr (sign);
  212.     sign = 0;
  213.     }
  214.     putchr ((char) ((n % 10) + '0'));
  215.     return;
  216. }
  217.  
  218. putx (n, s)
  219.     unsigned long   n;
  220.     int             s;
  221. {
  222.  
  223.     if (n > 0xf)
  224.     putx ((n >> 4) & 0xfffffff, --s);
  225.     else {
  226.     while (s-- > 0)
  227.         putchr (' ');
  228.     }
  229.     putchr ("0123456789abcdef"[n & 0xf]);
  230.     return;
  231. }
  232.  
  233. prtn (n, s)
  234.     long            n;
  235.     int             s;
  236. {
  237.  
  238.     switch (ibase) {
  239.  
  240.     case 8:
  241.     puto (n, s);
  242.     break;
  243.     case 10:
  244.     putd (n, s);
  245.     break;
  246.     default:
  247.     case 16:
  248.     putx (n, s);
  249.     break;
  250.  
  251.     }
  252.     return;
  253. }
  254.  
  255. prt (s)
  256.     register char  *s;
  257. {
  258.  
  259.     while (*s)
  260.     putchr (*s++);
  261.     return;
  262. }
  263.  
  264.  
  265. relsym ()
  266. {
  267.     register struct symbol *sp;
  268.     extern struct basepg *bpage;
  269.  
  270.     sp = binary.symptr;
  271.     while (sp) {
  272.     sp->value += (long) bpage->p_tbase;
  273.     sp = sp->next;
  274.     }
  275. }
  276.  
  277. mwsetsym (fid, ssize)
  278. /* read symbol table in MWC format */
  279.     int             fid;
  280.     long            ssize;
  281. {
  282.     struct mwfilsym sym;
  283.     char            ct;
  284.     
  285.     if (0 != (ssize % sizeof(sym))) {
  286.     if (ssize <= 0x30L)
  287.         return 0;
  288.     lseek (fid, 0x30L, 1);  /* skip some really not-symbol stuff */
  289.     ssize -= 0x30L;
  290.     }
  291.     do {
  292.     if (read (fid, &sym, sizeof (sym)) != sizeof (sym))
  293.         return -1;
  294.     if (sym.flag & 0x1000) {  /* global data */
  295.         ct = sym.sval.got[0];
  296.         sym.sval.got[0] = sym.sval.got[1];
  297.         sym.sval.got[1] = ct;
  298.         ct = sym.sval.got[2];
  299.         sym.sval.got[2] = sym.sval.got[3];
  300.         sym.sval.got[3] = ct;
  301.         if (0 == addsym (&binary.symptr, sym.name, sym.sval.value))
  302.         break;
  303.     }
  304.     } while (0 < (ssize -= sizeof (sym)));
  305.     return 0;
  306. } /* mwsetsym */
  307.  
  308.  
  309. setsym (fid, ssize)
  310. /* Read symbol table in Alcyon format - used by Sozobon as well.    */
  311. /* This function modified to handle also symbol tables where symbol */
  312. /* name possibly extends into the next symbol slot; only when       */
  313. /* signalled by S_LNAM flag, otherwise backward compatible.        */
  314.     int             fid;
  315.     long            ssize;
  316. {
  317.     register int extsymbs;
  318.     struct filsym sym; /* dummy for #defines - Sozobon doesn't know what
  319.                    to do with sizeof(struct filsym) */
  320. #define SYMSPAN sizeof(sym)
  321. #define NAMSIZE sizeof(sym.name)
  322.  
  323.     struct  {
  324.     char    xname[NAMSIZE + SYMSPAN];
  325.     short    xflag;
  326.     long    xvalue;
  327.     } xsym;
  328.  
  329.     extsymbs = (22 == swidth);
  330.     do {
  331.     if ((read (fid, &xsym, NAMSIZE) != NAMSIZE) ||
  332.         (read (fid, (char *)(&xsym) + NAMSIZE + SYMSPAN, SYMSPAN - NAMSIZE)
  333.                 != SYMSPAN - NAMSIZE))
  334.         return -1;
  335.     if (0 >= (ssize -= SYMSPAN)) {
  336.         xsym.xflag &= ~S_LNAM;
  337.     }
  338.     if (extsymbs && (S_LNAM == (xsym.xflag & S_LNAM))) {
  339.         if (read (fid, (char *)(&xsym) + NAMSIZE, SYMSPAN) != SYMSPAN)
  340.         return -1;
  341.         ssize -= SYMSPAN;
  342.     }
  343.     else {
  344.         xsym.xname[NAMSIZE] = '\0';
  345.     }
  346.     if ((xsym.xflag & S_EXT) &&
  347.         (xsym.xflag & (S_DATA | S_TEXT | S_BSS))) {
  348.         if (0 == addsym (&binary.symptr, xsym.xname, xsym.xvalue))
  349.         break;
  350.     }
  351.     } while (ssize > 0);
  352.     return 0;
  353. } /* setsym */
  354.  
  355. #undef SYMSPAN
  356. #undef NAMSIZE
  357.  
  358. addsym (spp, name, value)
  359.     struct symbol **spp;
  360.     char           *name;
  361.     long            value;
  362. {
  363.     register char  *cp, *cps, *cptr;
  364.     long            v;
  365.     struct symbol  *sp;
  366.     char           *malloc ();
  367.     struct symbol  *p;
  368.     int             msize;
  369.  
  370.     v = value;
  371.     sp = *spp;
  372.     while (sp && (sp->value <= v)) {
  373.     spp = &sp->next;
  374.     sp = *spp;
  375.     }
  376.     
  377.     cps = name;
  378.     cp = cps + swidth;    /* max symbol size */
  379.     while ( *cps && (cps < cp))
  380.     cps++;
  381.     cp = name;
  382.  
  383.     msize =  sizeof (*p) + (int)(cps - cp) + 1; /* need a space for '\0' */
  384.     if ((p = (struct symbol *) malloc (msize)) == 0) {
  385. /*        prtf("can't allocate %i bytes for symbol\n", sizeof(*p)); */
  386.     prtf (M1, msize);
  387.     return 0;
  388.     }
  389.     *spp = p;
  390.     p->next = sp;
  391.     p->value = v;
  392.     cptr = p->name;
  393.     while (cp < cps)
  394.     *cptr++ = *cp++;
  395.     *cptr = '\0';
  396.     return 1;
  397. }
  398.  
  399. int
  400. extndsymb(fid, ssize)
  401. /* check if any symbol in a file is in an extended format */
  402.     int             fid;
  403.     long            ssize;
  404. {
  405.     register int extended;
  406.     struct filsym sym;
  407.     long position;
  408.     extern long tell();
  409.     
  410.     position = tell(fid);
  411.     do {
  412.     if (read (fid, &sym, sizeof (sym)) != sizeof (sym))
  413.         break;
  414.     if (extended = (S_LNAM